When performing data processing operations on floating point data elements, it is often the case that a floating point constant is required as one of the input floating point data elements. In the execution of any particular program, it is likely that a number of such floating point constants will be required. If a program is considered as having an instruction area containing the instructions making up the program, and a data area containing data required when executing the program, then typically any required floating point constants will be specified in the data area of the program. When the program is installed on a data processing apparatus, these various floating point constants will be stored within memory, and accordingly will occupy valuable space within the memory.
Furthermore, when during the execution of a program a particular floating point constant is required, it will first be necessary to load that floating point constant from memory into a specified register. Typically, the required floating point constant will be identified by the generation of a pointer to the location in memory storing that constant. It will be appreciated that this will have an adverse effect on the performance of the program, since it will take time to establish the required pointer, and additional time to then load the floating point constant from memory into the required register, and these steps need to be taken before the operation that is to make use of that floating point constant can be performed.
In addition, it can be seen that the need to provide a load instruction in order to load the floating point constant from memory to a specified register adversely impacts code density. Further, the width of the bus connecting the data processing apparatus with the memory system will determine the bandwidth available for performing load operations, and accordingly it can be seen that each time a load operation is required to move a floating point constant from memory to a register, this will use a portion of that load bandwidth, which is then not available for use in performing other load operations required by the program.
Whilst the above technique has been described in connection with the loading of floating point constants from a memory into a register prior to its use within a data processing apparatus, the same process can also be used to load integer constants from memory into a register. However, for integer constants a more efficient process has been developed. In particular, it is known to encode within a particular instruction an immediate value which can be used to produce an integer constant for storing within a register. For example, a move instruction may have encoded therein an immediate value, and execution of the move instruction will cause the immediate value to be expanded as required to the size of a register, and then stored within a particular register identified by the move instruction.
As a particular example, in situations where a 32-bit instruction set is used, a certain number of bits of the instruction encoding space, for example 8 bits or 12 bits of the 32-bit instruction, will be used to specify an immediate value. If the register into which the integer constant specified by that immediate value is to be placed is a 32-bit register, then the immediate value can be zero extended (in the example of an unsigned integer constant) or sign extended (in the example of a signed integer constant) to 32-bits and then stored within the specified register. It has been found that such an approach enables a useful range of integer constants to be specified by an immediate value encoded within an instruction. It will be appreciated that the range of possible immediate values defines a corresponding continuous range of integer constants, and it is often the case that that continuous range of integer constants includes most integer constants that are considered useful in integer processing operations.
As a further enhancement to the above approach, ARM Limited have provided in their instruction set an instruction encoding which allows an 8-bit immediate value to be specified, and then a further 4-bits to be specified to identify a rotation to be applied to the immediate value in order to specify its location within a register (with the remaining bits of the register being filled with a predetermined sequence of ones or zeros). By allowing an immediate value to be specified, along with a rotation to be applied to that immediate value in order to determine its location within the register, further flexibility in the choice of integer constants is provided.
It will be appreciated that the use of an immediate value encoded within an instruction as the means for specifying an integer constant provides significant performance improvements over the earlier described prior art, where the constant was first stored in memory, and then loaded from memory into a register as required. In particular, by encoding the immediate value within the instruction, there is no need to perform a load operation, thereby improving code density, and increasing performance. Further, space in memory does not need to be set aside for the storing of such constants.
However, whilst useful integer constants can readily be specified by an immediate value encoded within an instruction, since there is a clear correspondence between the range of immediate values specifiable within the instruction encoding and the corresponding range of integer constants, this is not the case for floating point constants. In particular, floating point numbers have a more complex representation than integer numbers, a floating point number having a sign field, an exponent field, and a fraction field contained therein. In addition, the useful floating point numbers that are likely to be required as floating point constants do not follow any clear sequence, and accordingly it has up to now been considered not possible to represent a useful range of floating point constants through use of an immediate value encoded within an instruction.
Accordingly, up to now, when floating point constants are required, they are first loaded from memory into a register using the earlier described prior art techniques. However, as mentioned earlier, such an approach has an adverse effect on performance and code density, and also causes valuable memory space to be used for storage of required floating point constants. Accordingly, it will be desirable to provide an improved technique for providing floating point constants for use in floating point operations.